Tag: ci

  • What DevOps Skills are Organizations Looking for?

    What DevOps Skills are Organizations Looking for?

    DevOps is a cultural, philosophical and organic approach toward automating workflow and getting products to market more efficiently and effectively.

    DevOps engineers are in top demand right now. According to studies by Gartner, 25 percent of top global 2000 organizations will have adopted DevOps as a mainstream strategy by the end of 2016.

    DevOps is both a cultural movement and a philosophy … which can make it difficult to define the specific skill set you need a DevOps team to possess in order to function successfully.

    Of course, an excellent way to show fluency in DevOps is by earning a DevOps Institute certificate—for example, DevOps Foundation®.

    That being said, there are some “mission-critical” DevOps skills that organizations are searching for pretty universally right now.

    1. Experience with infrastructure automation tools and fluency in web languages

    Experience with tools such as Ansible, SaltStack, Puppet, Docker, Chef and Windows PowerShell DSC as well as fluency in languages including Ruby, Python, Java and PHP are must-have skills for DevOps pros.

    Organizations are searching for DevOps candidates who are highly proficient in many of these tools and languages and open to increasing their competencies further when given the opportunity to do so.

    2. Expertise in “soft skills”

    DevOps evolved as a way to enhance collaboration across project life cycles and connect front-end and back-end professionals on either side of the software development and operations spectrum.

    When software developers and operations staff (system engineers, systems admins, DBAs, etc.) collaborate effectively, communicate honestly and work as a cohesive team, the software development life cycle (SDLC) is streamlined, risk factors are mitigated, and projects are completed and deployed with a minimum of bugs, quality defects and glitches.

    In addition, it can be useful for organizations to have DevOps specialists on their team who are comfortable in the role of client consultant, able to interact effectively and build positive business relationships with customers while addressing their needs and wants.

    Organizations look for DevOps candidates who are skilled in interpersonal communication, with an arsenal of listening, negotiation, problem-solving and team-building skills at the ready.

    3. Familiarity with CI (continuous integration) tools

    Continuous integration is a DevOps methodology that continually merges source code updates from all developers on a specific software build, notifying the team of any failures in the process.

    This offers a real-time window into the developing software system, allowing immediate and constant engagement of all team members throughout the project lifecycle.

    CI tools DevOps candidates should be familiar with include CruiseControl, CruiseControl.NET, Jenkins, Bamboo, Hudson, ThoughtWorks’ Go, Urbancode’s Anthill Pro, Microsoft’s Team Foundation Server and Jetbrains’ Team City.

    4. Bonus Skills

    Other skills hiring managers are on the lookout for in the DevOps space include:

    • Extensive knowledge of software build cycles
    • Experience deploying code
    • Experience in software architecture
    • Familiarity with application programming
    • Database management
    • System design

    Useful experience and certifications include:

    • Project Management
    • Risk Management
    • Scrum Master

    The good news is that the industry’s need for DevOps team members with diverse and evolving skill sets is in sync with what DevOps candidates want from their workplace. According to the 2014 State of DevOps Report from Puppet Labs, an atmosphere conducive to learning is a primary component of job satisfaction among DevOps engineers.

    About the Author / Robin Borough

    Robin BoroughRobin Borough is President of Omnikron Systems, Inc., which offers IT and management training and IT staffing services. As an advisor to technology professionals and executives for over 25 years, Robin has built a world-class reputation as a “go to” career strategist in the IT industry, one who’s capable of successfully guiding executives and specialists, at any level, through transition. 

  • An Even More Modern Continuous Integration

    An Even More Modern Continuous Integration

    It would be strange for me to tell you that there is an even newer new approach to release automation, as if the processes of continuous integration (CI), continuous delivery (CD), continuous deployment and canary releases were not modern enough. And it would be even stranger to say that the open-source tool Jenkins, which dominates more than 60 percent of all release automation processes, is not enough for some, according to Salesify. But right now, I’m going to make the claim that all of the above is true.

    DevOps teams are impatient. They always want better. It is part of the enthusiasm that continuously pushes the modern delivery chain forward. But, of course, this change has to be throttled. This is why I look to companies who have found the proper mix of sustainability and modern tooling. When I met with TapInfluence, I was surprised to find out that even the “modern” tools of 2015 are not enough for the demands its applications are putting on application releases. And its new delivery chain is a powerhouse for releases and quality.

    Tapinfluence is a SaaS platform for initiating and managing influencer marketing campaigns. The company has 60 employees and growing with engineering based in Mountain View, California, and HQ in my home state of Colorado. Up to this point, the application has grown organically from a minimal viable product (MVP), which was driven primarily by a stream of requirements that came up and then adopted, to an established web application built on modern development principles. The incremental improvements are in the spirit of modern development, but it did not make for a sustainable delivery chain—or a delivery chain at all. The company lacked the practices of release automation and infrastructure you would expect.

    That is why when Tapinfluence raised its latest round of funding, it was not only meant to grow sales and marketing. The funding was also intended to build a more mature development operation to keep up with the growth of the platform and make sure all the new functionality did not come with technical debt.

    Kabriel Robichaux became the first director of engineering, and boy, did he have a lot of cool stuff to bring with him. Nearly from day one, Robichaux was preparing for team growth (from four to an estimated 20 team members in the next year), and significant changes to modernize the infrastructure and processes in the existing development team. This included Docker and a new release automation tool called Codeship. It was Codeship that got my attention.

    Robichaux had a lot of experience in releases automation already. “I have lots of experience with Jenkins, but working in a startup, a hosted CI solution was a key feature.” But, of course, cloud-based is not the only thing. After all, you can put Jenkins in your own cloud fairly easily.

    But Robichaux’s top considerations went beyond the purely technical and into their relationship to the community. He explained to me that when he adopts tools, he finds alternatives to the most popular tools, and checks them all out. He looks at tools from not only the perspective of their core functionality, but also whether they are committed to growing the market.

    So we’re not talking about a new generation of release automation. Release automation is just a workflow tool. It is how the tools approach the market. And it is a tremendous coincidence that he works for an influencer marketing company, and made a deliberate choice to look at how Codeship influenced the market. “I loved Codeship because they have an opinion, they are consistent with it, and they share it. For example, they believe that everything should be in source control, and so do I.”

    Considering that I work for a company rooted in developer communities, I have seen this social aspect of tool adoption as well. And it is growing rapidly. Given all the noise, it is not enough to have one or two features that do things better than the other guy. You have to be something more than a product or brand. Getting back to tactics, full control as also imperative.

    He said, “I need to be able to customize everything without jumping through hoops. I want to launch it, get to the terminal window, and start adding steps. The release automation tool, if working properly, should be transparent. I want to focus on the steps in the process, not how to run the tool.” Showing that he understands that there is an effort cost in utilizing and being an expert in a tool, which should not be required.

    The other element of a modern release automation tool (assuming you are on the bandwagon of the container-driven pipeline), is the container-native status. Codeship and CodeFresh, two relatively new tools, are both hanging their hats on container-native applications, and assume you are running your application on containers and/or microservices.

    Tapinfluence is one of a handful of paying Docker customers. And they are taking it one step further than most by Dockerizing their entire development environment. “In 30 minutes, someone could go from having nothing on their machine, to a full dev environment and ability to commit and deploy,” Robichaux explained, which is critical, as he not only has to support the core development team, but also data scientists who know how to code, but do not know the ins and outs of the application or how to create a build they can work against.

    “Normally it would take three or four days of training to get someone up and running,” Robichaux said. Given the pace of the changing environment, he simply can not waste time getting new devs going.

    Tapinfluence’s application runs on AWS, and it uses Convox to manage both its developer and production instances. As he said above the source repository is key, and Git is central to everything. Git is where all the vetted Docker Compose files are stored. The DevOps teams vet the core images, and developers manage the delta for the particular service they are working on. The net result is a unified delivery chain that can do a release within five minutes.

    If I were to speak with Robichaux even a month from now, I would likely be shocked again at the amount of change his company has gone through. But, it is keeping an application up and running and delivering the results its customers expect.

    In the true DevOps spirit, the goal should always be to push the needle toward faster, more frequent releases at a higher quality. If you stagnate with one stack, you will not be a DevOps environment by the end of the year.

  • DevOps Chat: Steve Hazel, Sauce Labs

    DevOps Chat: Steve Hazel, Sauce Labs

    I recently had the chance to sit down and speak with Steve Hazel, CTO and co-founder of Sauce Labs. With so much being written and talked about the role of quality assurance (QA) and testing in a continuous integration/continuous delivery (CI/CD) world, it is good to hear from someone like Steve who is an actual thought leader in the space. Steve tells us what he thinks the limits of automated testing are, the future of QA and more. Have a listen for yourself to find out, or follow along with the printed transcript below!

     

    Alan Shimel: Hi, everyone. Alan Shimel, devopsy.kinsta.cloud here, for another DevOps Chat. Today’s DevOps Chat’s guest—that was a tough one—is Steven Hazel, co-founder, CTO at Sauce Labs. Steven, welcome to DevOps chat.

    Steve Hazel: Hi, Alan. Glad to be here.

    Shimel: Thank you. Glad to have you here, actually. So Steven, there might be some people listening who maybe aren’t familiar with Sauce Labs. So, before we start, why don’t we, if you don’t mind, give our listeners a quick overview? Tell us about Sauce Labs.

    Hazel: Yes. At Sauce Labs, we do automated testing for both web and mobile apps. We run a cloud service that gives our customers access to a wide range of platforms, whether that’s operating systems and browsers for web testing, or mobile devices and emulators and simulators for mobile testing. You can get access to all the different platforms you need to test on, and you can get access to a lot of platforms at once to run your tests in parallel to get through a large test suite rapidly, which is really what people need for today’s continuous integration and continuous delivery workflows.

    Shimel: Got it. Of course, Steven, Sauce Labs was closely linked with around Selenium and some of the open-source testing tools that are out there today, right?

    Hazel: That’s right. Selenium is the dominant web-testing technology. In mobile testing, there’s a variety of technologies, but we support Appium, which also uses the web driver protocol that underlies Selenium. We really think that fitting in with those open-source tools is the smart way to go. It fits with what people are doing.

    It gives people a lot of choices about how they want to do their testing, what kind of languages and frameworks they want to use on their end. So, we just plug right into Selenium tests, if you’ve already got Selenium tests, or Appium tests. You can just change the config and point them at Sauce Labs, and they’ll run unmodified on our systems.

    Shimel: Got it. Steven, we were talking before we started recording today, I was telling you about a recent article we had over on devopsy.kinsta.cloud. The gist of it was basically that DevOps was the death knell for QA. I told you I didn’t agree with that and you agreed with me. You said you didn’t agree with it, either. But for our audience—they’ll respect you a lot more than they respect me—why don’t you agree with that, Steven?

    Hazel: Yeah. I think that to suggest that there’s no longer a role for manual QA when you take on a DevOps process is just not in line with the facts. If you look at what we see large organizations doing, they’re not dropping manual QA for automation. They’re changing the mixture of what they have manual testers doing by quite a lot, but they still have manual testing teams. You still need a manual testing team.

    So, what I see happening, as you start to take on automation, your testing coverage improves dramatically because you can afford to do a lot more testing when you’re automating than was ever possible with a manual testing team. But automated testing, the classic example is exploratory testing. You’re just not gonna get the kind of creative, exploratory walk-through of your app with an automated test that a manual tester can do. I think there’s still a role for QA organizations, beyond just manual testing, in being the other side of the conversation, right?

    A lot of people have the concern that if developers are writing tests, it’s the inmates running the asylum. The exact developers writing the software are the ones deciding whether it’s high quality, and you want another perspective in there. You want a perspective that’s maybe closer to your end user. So, I think that the other side, beyond just manual testing, that you see with QA teams continuing to have a role is in deciding what cases should be tested, whether you have good test coverage, encouraging good testing practices, even when you are automating your tests.

    Shimel: Absolutely. Really, Steven, I guess the boogeyman in the room around the friction with DevOps and QA is automation. There’s some schools of thought that says, “Well, we can automate everything. The more we automate, the better we are.” There’s another school of thought that says, “Well, you can automate as much as you can and automation’s not a bad thing, but there are just gonna be some things that are not automatable, if that’s a word now, or may never be automated. Where do you go in on that continuum?

    Hazel: Well, being someone who’s pushing forward automated testing, I want to see automation go as far as we possibly can. I think that that’s very far. That said, I think that the way the mixture of tests changes as you adopt automation is maybe a little bit counterintuitive. You might imagine, well, we’ll automate some percentage of our manual test cases, maybe 80 percent or 90 percent. Maybe we could get to 100 percent if you’re a zealot for automation.

    But actually, what you see is, it’s not that you’re automating a percentage of what was there in manual testing. You’ll actually have more automated test cases than you were able to do with manual testing. So, if you just looked at the number of test cases, your automated cases are gonna way outnumber the original count of manual test cases just because you can, right? You can now cover a lot more edge cases, a lot more scenarios because of the power of test automation. So, that’s a real advantage to test automation.

    Shimel: Sure.

    Hazel: At the same time, certainly there are things, visual testing, there’s some interesting approaches out there, but I don’t think we’ve yet seen a way of making sure that the app looks right, especially as it changes. You really need a human being involved when there are deliberate visual changes to make sure that they came out right. I think it’s those things where automation really can’t give you an answer about, does it look right? Does it act in a way that’s gonna be acceptable to somebody?

    I think you still need a human being in there at some point, checking those things, but it’s a different process. It’s no longer this phase gate before every change is released that you used to have. It’s now a process that can be made asynchronous from the bulk of your development and release process.

    Shimel: Absolutely. If you don’t mind, Steven, a little bit of time on, you mentioned a little bit, but what do you think of the kinds of tests that lend themselves well to automation? Certainly, a visual test of an interface, different arts. What are the sweet spots for automated testing?

    Hazel: I think certainly at the bottom of the testing pyramid, unit testing brings tremendous value. It’s something that’s very easy to automate in a way that’s completely deterministic, very fast. Gives you really quick feedback as a developer as you’re making changes to the code on whether you’ve broken something. But the coverage with unit testing, the coverage of functionality that may be important to your end users, it’s really hard to achieve. It’s really hard to achieve good, solid feedback from your unit tests that you haven’t broken anything anywhere.

    Functional testing, the next layer up, which is what really we focus on, gives you that complete end-to-end check. You’re actually testing the features of your product and you’re making sure that end to end, with all the various components involved, they work properly. That’s more of a challenge for automation, but we’re seeing, I think, a majority of development organizations out there seeing success automating functional tests and real value from having that be something where you can run through hundreds of test cases in minutes and get feedback to your team. So, that works quite well for automation.

    I think it’s that next level up, as you start to get into the types of tests where you’re looking at, what’s an acceptable experience for the end user? User acceptance testing as distinguished from functional testing, where you’re really starting to look for, does it look right? Does it act right? Is the response time throughout the entire process acceptable?

    You can zoom in and measure a lot of these things very specifically, but getting the answer to, “Overall, though, was it a good experience?” That’s the kind of thing where it’s really tough to cover that with automation.

    Shimel: Yeah, agreed. Steven, if you don’t mind, I’m an old security guy prior to DevOps. One of the things within the security community that we’ve really pushed around is the idea of automated security testing shifting left in a DevOps environment and allowing security testing to be done in an automated fashion at a CI/CD-type of level. Where do you see that in this whole discussion?

    Hazel: Security testing isn’t what we focus on at Sauce Labs, so –

    Shimel: Right, I know.

    Hazel: I’m not an expert in this, but it is something that I follow and care a lot about. I think I see a lot going on with static analysis, with some of these tools that can help to constrain the types of mistakes that you could have in a program, type systems and things along those lines. I think really that’s very badly needed in making code secure. Some of the issues we’ve seen come up over the last few years, things like Heartbleed, the Glibc bug, really those kinds of things aren’t acceptable, aren’t something that we can continue to have happen, and I think the solution really is fully automated tools, like static analysis tools and type systems, that can lock down the code and just constrain the types of mistakes that could possibly happen.

    Shimel: Sure. You know, Steven, I see it as very analogous to the QA situation, which is I think a lot of security people get very territorial around job security because they’re afraid somehow that doing automated security testing earlier in the process—shifting left, so to speak—is somehow gonna affect their livelihoods, or make them obsolete.

    Hazel: I can see that. We see that among QA folks, for sure. To me, that’s a shortsighted view. If the world is getting more intense security problems, more intense quality problems, we’re shipping more software, you just can’t solve it 100 percent by throwing bodies at the problem. I think that what’s gonna happen is not that those people’s careers are in jeopardy; instead, as a society, we’re just gonna do more and better security and quality testing than we’ve been able to do in the past.

    Shimel: Yeah, agreed. Steven, we’re running a little low on time, so let me get just one or two more questions. Sauce Labs has been, in my opinion anyway, for what it’s worth, somewhat of a DevOps darling in terms of really encompassing—you’re living the DevOps model. You’re working with open-source tools, testing and automation, enabling automation. Sauce Labs is a player in the DevOps ecosystem. Where do you see it going?

    Hazel: Well, toward the enterprise is one big trend we’re seeing. Earlier on in the history of Sauce Labs, a lot of our customers were essentially software companies, companies that their primary focus is technology. Now, a lot of our customers are retailers, financial institutions—companies that you don’t think of as primarily a software company, but all of these companies have apps, they have complex web experiences. They’re really adopting DevOps in a big way. They’re moving to what is, for them, a very different process than what they’ve been doing and allows them to ship better software faster, with more complexity than they were able to handle before.

    Shimel: Absolutely. Steven, we are low on time. I’m gonna ask you the final question, which I ask most all of my guests here on DevOps Chats. That is, if you had to recommend one book to our audience that they should read, a must-read for them, over the next six months or a year, what would that book be?

    Hazel: Oh, wow. A book recommendation. I think the obvious choice in a conversation about DevOps is “The Phoenix Project.” If you haven’t read it, you’ve got to read it. It’s a quick, enjoyable read, but it really gets the concept across better than probably anything else is going to. It’s an obvious recommendation, but I still think it’s worth it.

    Shimel: Sometimes the obvious is good. I will just add to that, if you already have read “The Phoenix Project,” Gene Kim’s next book, I think co-written with John Willis and Jez Humble and someone else that I’m blanking on – oh, darn it, the guy who started DevOps, who coined the phrase. Patrick. Patrick Debois. Their new book, I think it’s called “The DevOps Handbook,” will be out, I want to say, in the fall. Not a sequel to “The Phoenix Project,” but another good book to look at.

    Anyway, Steven Hazel, CTO, co-founder of Sauce Labs, thanks for being this episode’s guest on DevOps Chat, and continued success with Sauce Labs.

    Hazel: Thanks a bunch. Thanks for having me.

  • DATICAL DEBUTS CONTINUOUS INTEGRATION SOLUTION FOR THE DATABASE

    Datical DB 4.0 keeps database administrators from having to review vast majority of database changes

    Austin, Texas – July 7, 2016 – Datical, the leading provider of agile database automation solutions, today announced Datical DB 4.0. This latest release seamlessly maps development-driven database change management to proven continuous integration (CI) workflows. These modernized database change workflows closely parallel the way application code is managed in highly automated environments.

    Datical DB 4.0 includes a new Automated Deployment Packager that allows database changes to be continually validated, packaged and integrated via more pervasive, hands-off automation. Datical DB’s automation capabilities drastically reduce the amount of time database administrators (DBAs), developers and QA teams spend managing these changes from ideation to production deployment.

    The Automated Deployment Packager empowers DBAs to keep pace with accelerating application releases by offloading the majority of manual review, approval and deployment activities each time a database change is requested by development. By employing Datical’s Automated Deployment Packager, database developers are now able to check change scripts for popular database platforms like Oracle, Microsoft SQL Server or IBM DB2 into source code control solutions like Git, Apache Subversion or Team Foundation Server. This triggers a process that automatically accepts or rejects the proposed changes based on validation routines defined and customized by seasoned DBAs.

    Validation routines ensure that changes are well designed and compliant with organizational standards and best practices. The routines keep DBAs from being involved, unless there is a particularly important reason for them to be.

    “Upwards of 90 percent of developer scripts and database changes don’t need to be touched by a DBA, and with Datical 4.0, DBAs only need to involve themselves with the small subset of changes that do require their attention and expertise,” said Pete Pickerill, co-founder and VP of product at Datical. “This release is giving DBAs back their time, focus and sanity in helping them return to the role they were meant to play.”

    Over time, automated validation and detailed reporting help developers build an understanding of the difference between an acceptable change and a change that will break the build.

    Once a set of changes is approved, it is packaged and labeled for easy deployment to other environments through tight integrations with popular build and release automation tools like Jenkins, IBM UrbanCode, XebiaLabs XL Deploy or Electric Cloud ElectricFlow, or by using Datical’s graphical or command line interfaces. Database change management becomes a self-service experience for development, test and operations teams. As a result, DBAs are freed up for more strategic pursuits like performance tuning, capacity planning and the evaluation of new technologies and data platforms.

    Lastly, Datical’s Automated Deployment Packager also eliminates the painful task of reconciling partially-updated database environments by ensuring that the environment always reflects the latest approved version or else reverts back to the most recent wholly-approved, backed up and stored version, all with minimal downtime.

    “As we’ve looked to involve the database in continuous integration, we’ve found that Datical represents the ideal pathway,” said Devon Siegfried, database architect at Radial, formerly eBay Enterprise. “There’s honestly no substitute for the way that Datical allows us to deploy database changes in such an effective, closely tracked and controlled manner. To top it all off, Datical’s implementation and product teams have been unmatched.”

    To learn more about Datical DB 4.0 or to request a demo, please visit: www.datical.com.

    About Datical Inc.

    Datical’s mission is to radically improve and simplify the application release process by automating database management. Datical solutions deliver the database automation capabilities technology executives need to get the most out of their Agile, DevOps and Continuous Delivery investments. With Datical agile database automation organizations can shorten the time it takes to bring applications to market while eliminating the security vulnerabilities, costly errors, data loss and downtime often associated with current database deployment methods. For more information, visit www.datical.com, call 949-DATICAL or connect via @datical.

     

  • Trust, You Must: 8 Tips for Adopting CI/CD

    Trust, You Must: 8 Tips for Adopting CI/CD

    We have done continuous deployment (CD) for four years, and enable many of our customers to do continuous deployment with quality assurance (QA). We’ve helped tons of companies adopt and optimize their CD setups. We’ve found that continuous deployment is all about trust — augmented with processes and infrastructure.

    To that point, here are some common tips for adopting continuous integration (CI)/CD that I find myself sharing frequently:

    Use a CI Tool

    This sounds obvious, but you’d be surprised at how many companies try and roll their own. Don’t. There’s no upside for your company—and infinite downside. We love Circle, but there are plenty of other great options. Most are at least somewhat prescriptive when it comes to workflow, which is important when you’re getting started.

    Do Unit Testing

    It’s always worth reminding everyone that continuous deployment is simply continuous integration applied to deployments. To do continuous integration, you need good unit test coverage. If you haven’t got a solid base of unit testing and continuous integration already, you’re not ready for continuous deployment.

    Have Solid Production Monitoring

    Bugs and regressions will get shipped; it’s inevitable. Put a system in place, by looking at the data in production, to tell you when a regression or bug was shipped. Tie this into automated rollbacks, so that if a significant performance or key performance indicator (KPI) regression (i.e., signups per minute) appears, your CD system rolls back to the most recent stable version while your team investigates.

    Trust Your Team

    We talked about the infrastructure requirements, but if you don’t have trust, then continuous deployment isn’t going to work for you. Trusting your team is about giving your developers the freedom to make mistakes, deploy as they see fit and check each others’ code. It is possible to combine continuous deployment with a culture of hierarchical permissions, but we have yet to see that truly work.

    Remove Red Tape from the Code Review Process

    Your team should review code changes, typically through a pull request, which goes hand in hand with trusting your team. Developers should be trusted to choose the most qualified and insightful person to review their code. One of the most common mistakes among teams trying to adopt continuous deployment is that they only let one or two “senior” developers review the rest of the team’s code, “bottlenecking” all releases. Don’t make this mistake.

    Involve Developers Closely in Production Operations

    The most common mistake we notice among companies that don’t make a successful transition to continuous deployment is that their development organizations are siloed. Dev and Ops should be joined at the hip. Have your developers deeply involved in the setup and definition of your CD infrastructure, and half the battle is already won.

    Shift Left: Test Early and Often

    Your team needs constant feedback. Think of your QA objective as getting the right feedback in the right hands at the right time. When it comes to deployments, this means knowing what’s working and what’s broken as the breaking change is made. The sooner you uncover the bug after it’s created, the easier it is to fix. The best companies doing continuous deployment have comprehensive unit test and integration test coverage that runs before any code hits the staging server.

    Treat Staging as Your Holy Place

    The final pre-production environment is usually known as ‘staging.’ A common mistake is to have developers ship new code direct to staging, while figuring out if the new code is ready to go live. This is a terrible idea. As soon as more than one developer is trying to ship their changes, your Slack channel will blow up with cussing and recriminations. Isolate the pre-production environments to each project, and enforce the “staging as ready to go live” philosophy. This way, integration testing can happen at a self-defined pace, without anyone else’s release being blocked.

    About the Author / Fred Stevens-Smith

    fredstevenssmithFred Stevens-Smith is Co-founder and CEO of Rainforest QA, a quality assurance-as-a-service startup backed by Storm Ventures, Rincon, Andreessen Horowitz, Morado and Crosslink.

  • To Be Continuous: Does your company have to be all in to do Continuous Delivery?

    To Be Continuous: Does your company have to be all in to do Continuous Delivery?

    In this segment of To Be Continuous, Edith Harbaugh and Paul Biggar talk about the spectrum of continuous delivery and where continuous delivery will and will not work.

    Edith Harbaugh, CEO LaunchDarkly

    Edith is CEO and co-founder of LaunchDarkly, a continuous delivery tool of “feature flags as a service.” LaunchDarkly powers software teams to quickly launch, measure and control their features.

     

     

    Paul Biggar, CEO CircleCIPaul is founder of CircleCI, a continuous integration and deployment platform that automates development workflows and IT operations, allowing developers to ship quality software significantly faster.

     


    [soundcloud url=”https://api.soundcloud.com/tracks/231204216?secret_token=s-45TTy” params=”auto_play=false&hide_related=false&show_comments=true&show_user=true&show_reposts=false&visual=false” width=”100%” height=”166″ iframe=”true” /]


    Edith: So Paul, does one have to be all in to do continuous delivery?

    Paul: So I think the obvious answer is no. And in particular, you know that the answer must be no because nobody starts at all-in, or at least if you’re starting a new project you can be all in, and many projects are not all-in.

    So someone starts somewhere and they say, “Now we are going to do continuous delivery in some way,” and so they have to go from zero to full continuous delivery along some way.

    Edith:

    People have this conception that continuous delivery just means pushing any time you want, and a lot of very old school development shops did that. They would just hot patch and production constantly.

    Paul: Right. So, I mean, are we calling that continuous delivery? I feel that the idea of SSH-ing into the server is not continuous delivery somehow.

    Edith: But people have this misconception because they’re like, “Oh, I had a continuous delivery before this was a thing,  I just patched it production.”

    Paul: I’m going to put a lot of money on the line here and say that if you define continuous delivery as “I SSH into the production server,” then you are not doing continuous delivery right. In fact, you are doing it considerably wrong.

    Edith: What exactly are you doing wrong then? What steps are you skipping?

    Paul:

    The whole point is that you have this automated process for releasing software. And SSH-into the production server is the very opposite of that.

    That’s not to say you shouldn’t do it in the occasional emergency. And occasionally, if we have some sort of catastrophe, we will SSH into the production server, replace some code, execute some code on the server to keep things as they are and prevent customers from noticing or from things from going down.

    But that isn’t the same as a continuous delivery pipeline or a release workflow, or an automated release workflow, which is essentially what continuous delivery is.

    Edith: So continuous delivery isn’t just shipping stuff out to production, it’s more having all the processes behind it.

    Paul: It’s very much the process. So when you think about can you be a little bit continuous delivery, I think what you’re looking at saying is there a lightweight version where we get some benefits of the continuous delivery as we go between all and nothing?

    Edith: Can you be, do you have to be all in, or can you be a little bit continuous?

    Paul:

    I think the very obvious instance of a little bit continuous is where you deliver the code where you have the automated release process builds some sort of artifact and then someone manually deploys that by a single click.

    Or, in fact, where a build happens and test happens and the remaining automated release process is triggered by a human saying, “Now we are going to release,” and then everything else is scripted, and so they just have one input, which is now.

    Edith: Oh, that’s really interesting. So do you think to truly be continuous it has to all be completely automated with everything always pushed?

    Paul: No, no. I don’t think so. I think it largely depends on the size of the team and that sort of thing. But I’ve seen a couple of examples where our customers were asking for particular things, and it indicated that they had sort of semi-continuous workflows.

    And one example of that is a team that only wants to do continuous delivery during work hours.

    Edith: Yeah.

    Paul: And there was another team, which only wanted to do continuous delivery at midnight because that was the only time that they didn’t have enough customers on their site to be able to clear the caches.

    Edith: Yeah.

    Paul: Now if they wanted to go to complete continuous delivery they would have to say, “We are going to clear a subset of the caches,” or have some other caching policy that allows us to continue or that allows us to deploy at any time, but where they are is basically were semi-continuous.

    Edith: I had a really interesting chat with Douglas Squirrel, who actually listened to our podcast, and he does a lot of consulting for companies in England, and he said he goes to a lot of companies that have all the tooling to be continuous.

    Paul: Okay.

    Edith: But they don’t actually use it.

    Paul: And what does that mean exactly?

    Edith: They have set-up continuous integration, they could, in theory, deploy whenever they wanted but they still, for whatever reason, still cling to their old schedules.

    Paul: Okay. So, I was looking at this very interesting article on the First Round Capital blog.

    Edith: Oh Jocelyn’s.

    Paul: Yes, that sounds right.

    Edith: Jocelyn Goldfein, who is at Facebook, right?

    Paul: Yes, that’s right. Yes. So, what she talked about was this idea that delivery schedules are useful in certain contexts. And in some cases velocity matters, and that’s kind of the Facebook case, and in some cases predictability matters a lot more. And if you’re delivering enterprise software, for example.

    An enterprise is not going to allow you to continuously deliver your product into their firewall or into their enterprise. What they’re going to want is every quarter a new thing.

    Multiple times a year preferably, but each time you release to them it creates a new workflow, and they want to be able to audit it and see a change log and validate that things are, they might have a change process internally.

    And so it’s not necessarily going to be a good idea to continuously deliver there. But a team that is building for that can do a continuous delivery process internally where they produce all of the artifacts and they do a complete release on every single push. Even if that is not released.

    Edith:

    There are a lot of reasons why an enterprise doesn’t want to take new features constantly, and a lot of it comes down to training. If there are big new features that need to be rolled out to people then they have to take on the cost of training.

    Paul: Right.

    Edith: It was actually interesting. I chatted with a guy from Square and he talked about how they really try to limit the amount of pushes they put out to the actual cashiers.

    Paul: Okay.

    Edith: Because of the training cost. I mean, a cashier at a coffee shop is doing a gazillion other thing and they can’t just suddenly pop up some new functionality and expect them to grok it or even take a tour.

    Paul: Right. That’s an interesting idea.

    Edith: So, although they have all the processes in place to do a lot of changes, to do continuous delivery, they actually really limit what they push out to the true end users.

    Paul: And it’s funny that the people who have far, far more users, someone like Facebook, can just do those changes because they don’t necessarily value an individual user on a…

    Edith: You’re walking down a path.

    Paul: No, I’m not saying that they don’t value their users. It is safe to piss off an individual user. Less so for someone like Square. And as you go up the value chain, the more they’re paying you or the more involvement they have to have in the product decisions, the less able you are to piss them off.

    Edith: Facebook is actually a fascinating example because at any time they’re going to be pissing off somebody. It’s just a matter of, it’s kind of like Apple.

    Ya know?

    Paul: Right.

    Edith: They’re always pissing off somebody, it’s just who.

    Paul: Did you hear about today at Facebook where all the feature flags went on?

    Edith: It was LinkedIn.

    Paul: Oh, was it LinkedIn? Okay.

    Edith: Ya. Well, it probably has happened to everybody that’s done feature flags. There’s the day that that happens.

    Paul: Right.

    Edith: And, it’s ugly, yet. Facebook is fascinating. I actually, I wrote a blog post about Facebook and how they use feature flags. They have a product called Gatekeeper.

    Paul: Right.

    Edith: That controls everything, everything. And after they had a huge PR disaster, i think it was in 2011, with their news feed, they actually do really care if they piss off a lot of people.

    Paul: Right, right.

    Edith: And that’s why they implemented Gatekeeper where they do a lot of 1% roll-outs.

    Paul: So, I remember when I was setting up Circle I sat down and talked to my friend who worked at Facebook and talked about their workflow and that sort of thing, and their release process was that code got released on Tuesdays and everyone who was releasing code, or who had code in that bit that was going out, had to be available during the release process.

    And the release process didn’t turn on any features because that was all done by Gatekeeper, but the code itself had to go out. And they had to validate that everything stayed the same and everyone had to be there. And so they had a fairly continuous delivery process but were still, manually there was a release going out.

    Edith: Well ya. You want to have some sort of enforcement that people look at stuff and care.

    Paul: Care in what sense?

    Edith: So, the example I heard about also at Facebook is it’s so large that there’s just no way that all the groups can coordinate with each other. So literally what they do is when they roll stuff out with Gatekeeper they roll it out internally to Facebook-only employees and that’s how they find out if stuff breaks. It’s not like at a smaller company like CircleCI.

    Paul: Right. But there’s a difference between the code being rolled out and the feature being rolled out.

    And they don’t do, I don’t know what the story is nowadays, but at the time they certainly didn’t do continuous delivery on code. Or continuous releases or whatever you might call it.

    Edith: I don’t actually work at Facebook, but what I did hear was that– that they just literally can’t coordinate. When you’re a small company you can still coordinate in a HipChat or a Slack room like, “Hey, we’re pushing this now, start looking for changes.”

    Paul: Right.

    Edith:

    But with Facebook, the only way they know if something is broken is if somebody complains.

    Paul: So there’s an interesting discussion about microservices at AWS. I guess they didn’t call them microservices at the time, but having fully service oriented architecture.

    So, one of the things they talked about is how when you roll, or when you continuously deploy a service, you might break other services. So, the thing that actually breaks may not be in any way related to the people who’s alarms start going off. And, in fact, there may be multiple steps away from who’s alarms are going off.

    Edith: Google has a similar system, and I heard that they monitor 200 plus different metrics. And one of the ones they monitor is just do people say, “Gmail sucks more?” on Twitter.

    Paul: Oh. Interesting.

    The thing that I’m getting at in terms of how little or much can you continuously deliver is, if you are Google or you’re Facebook and you have the monolithic code repos, the thing that you’re releasing is it’s not the same release process as someone like Amazon who has what I would describe as pure, continuous delivery.

    Every service does it’s own continuous delivery and your dependencies may be changing at any time and you don’t actually know what’s going on. Versus Facebook, we are taking this multi-gigabyte binary and we’re uploading it to a set of servers, and sure, we’re slowly releasing and maybe we’re doing that multiple times a week or multiple times a day.

    But it’s not quite the same as Amazon releasing every 11 seconds. And I think we can see, even between these multiple large companies who have incredibly advanced release process, that you could say that they are clearly at different spectrums along continuous delivery.

    Edith: So, what do you think is suitable for, let’s say, a medium company with, let’s say, 10 developers?

    Paul: I mean, there’s a lot of different things going in. Who is your customer base? What is the level of safety that you need? Let’s suppose that it’s a consumer web app. If it’s a consumer web app, I would expect that that company should be continuously delivering all the time. Especially if it’s slightly okay to break things.

    Edith: Yeah.

    Paul: Or at least, you break things you can kind of roll them back or whatever within a couple of minutes. A team of that size might not have the resources to make their continuous delivery process perfect. But it seems likely that they would have more success shipping with continuous delivery than shipping without it. So lower risks, higher velocity. That sort of thing.

    Edith: It’s funny how continuous delivery has permeated even the VC world. Jason Lemkin, the guy behind SaaStr,

    Paul: Right.

    Edith: He tweeted yesterday that one of his due diligence questions was how,”How often can you roll back, and does it work?”

    Paul: Right.

    Edith: And it’s funny that I think of that as a very technical thing, like, “can you roll back?” But to the VC is seen as a sign of technical sophistication.

    For more on Continuous Delivery and to find out about new episodes you can follow the show on Twitter at @continuouscast.

  • CI of Complex Cluster Environment with CircleCI and DigitalOcean

    CI of Complex Cluster Environment with CircleCI and DigitalOcean

    At CloudSlang, we’re passionate about all thing open source. Integrating with other open source projects is a key part of what we’re all about. We focus on integrating with many cloud native technologies, such as CoreOS, Docker, and Consul.

    As such, it is important for us to test these integrations automatically as part of our CI. But setting up a complex cluster environment (like CoreOS/Swarm cluster) using popular CI solutions such as Travis or CircleCI for testing can be tricky.

    In this post we’ll outline how we test our content integrations using a combination of DigitalOcean, CircleCI and CloudSlang. The same formula can be used to set up your own complex testing environments.

    Recently CloudSlang introduced a testing framework to write tests for CloudSlang content and run them with the Build Tool. The Build Tool’s features include grouping tests into test suites and validating flow results, expected outputs or exceptions.

    CloudSlang has a fast growing repository of content which is housed on GitHub. When a flow in the repository is changed it can affect other parts of the content that depend on the changed flow. Therefore, it was crucial for us to come up with a proper CI solution.

    After investigating the available CI providers and our configuration needs, we decided to split our test suites in two categories and distribute them between CircleCI and Travis. Both solutions are based on the CloudSlang Build Tool to validate our content: CircleCI runs cluster related test suites (e.g. CoreOS, Docker Swarm) and base content (which does not require SSH access) while Travis handles most of the Docker content and flows that require access to the environment via SSH.

    Logical Steps of the Build Process

    The process begins with working on a local content repository. The content repository contains two main folders: content (for regular CloudSlang files) and test (test related CloudSlang files). The changes could be adding new content and tests or just updating the existing files.

    After the changes are completed they are committed to a working branch. When all the commits are ready, they are pushed to GitHub and associated with a pull request.

    Any changes pushed to the pull request trigger a CircleCI build which is configured based on a circle.yml file. CircleCI builds your code using Docker containers. Currently we use a parallelism of two containers, each of them running the Build Tool. Combining CircleCI’s parallel modifier and environmental variables (e.g. node index) you can specify if a command should be executed on every machine (downloading the Build Tool) or just a specific one (creating resources that are used by only one machine).

    circle.yml

    test:
      pre:
        - ? > ### machine 0
            if [ "${CIRCLE_NODE_INDEX}" = "0" ];
            then docker run -d -p 49165:8080 jenkins
            && docker run -d -p 8500:8500 -p 8600:8600/udp fhalim/consul;
            fi
          : parallel: true
        - if eval "${RULE_DROPLET_MACHINE_NOT_FORK}"; then chmod +x ci-env/create_droplets.sh && ci-env/create_droplets.sh; fi:
            parallel: true ### machine 1
        - ? > ### every machine
            wget https://github.com/CloudSlang/cloud-slang/releases/download/cloudslang-0.8.0/cslang-builder.zip
            && unzip cslang-builder.zip -d cslang-builder
            && chmod +x cslang-builder/bin/cslang-builder
            && mkdir cslang-builder/lib/Lib
            && pip install -r python-lib/requirements.txt -t cslang-builder/lib/Lib
          : parallel: true
        - ? > ### machine 1
            if eval "${RULE_DROPLET_MACHINE_NOT_FORK}";
            then chmod +x ci-env/wait_for_droplets_and_update_test_inputs.sh
            && ci-env/wait_for_droplets_and_update_test_inputs.sh;
            fi
          : parallel: true

    On the first machine (machine 0) the default test suite is activated. It verifies the base content which includes things like working with files or string operations. This test suite does not require additional environmental configuration.

    Tests running on the second machine (machine 1) require additional configuration. In this case we are using a cluster of CoreOS machines as the infrastructure used by the test flows. We use DigitalOcean to create and manage the CoreOS machines (droplets). Each build has its own set of droplets named after the following convention: ci-{build_number}-coreos-{machine_number} so the builds are running completely independently.

    Once all the parallel executions finish running, CircleCI collects and evaluates the build result. CircleCI also publishes an artifact called execution.log which is created by the Build Tool and contains relevant logging information about the execution – which can be very useful when debugging flow executions.

    Running tests against the droplets

    The second container’s execution phases are presented in the following image:

    These steps use bash scripts to execute relevant commands. The scripts and configuration files can be found under the ci-env directory. Droplets are created and managed using DigitalOcean’s REST API. The first step (create_droplets.sh) generates a discovery URL for the CoreOS cluster and updates the cloud-config file with the newly created URL. The  cloud-config file contains regular CoreOS configuration data for the cluster (private networking configuration, starting up services like etcd and fleet) and a write_files section where we prepare a unit file (docker-tcp.socket) for the Swarm use cases (this socket will be used to enable Docker Remote API). Once the cloud-config file is ready we can create the droplets by sending POST requests to DigitalOcean:

      CURL_OUTPUT=$(curl -i -s -X POST https://api.digitalocean.com/v2/droplets \
                    -H 'Content-Type: application/json' \
                    -H "Authorization: Bearer ${DO_API_TOKEN}" \
                    -d "{
                      \"name\":\"${COREOS_MACHINE}\",
                      \"ssh_keys\":[${DO_DROPLET_SSH_PUBLIC_KEY_ID}],"'
                      "region":"ams3",
                      "size":"512mb",
                      "image":"coreos-stable",
                      "backups":false,
                      "ipv6":false,
                      "private_networking":true,
                      "user_data": "'"$(cat ci-env/cloud-config.yaml | sed 's/"/\\"/g')"'"
                    }')

    The request is dynamically generated using global environmental variables defined in the project’s properties page (DO_API_TOKEN, DO_DROPLET_SSH_PUBLIC_KEY_ID), environmental variables defined in the script (COREOS_MACHINE: name of the machine, depends on build number) and cloud-config file. The script also verifies that the requests were accepted by DigitalOcean (status code: 202) storing the droplet IDs in an array:

    DISCOVERY_URL: https://discovery.etcd.io/5f30dd91642ae055ff24efd6b2359f3d
    ci-1439-coreos-1 (ID: 6748964) droplet creation request accepted - status code: 202
    ci-1439-coreos-2 (ID: 6748965) droplet creation request accepted - status code: 202
    ci-1439-coreos-3 (ID: 6748966) droplet creation request accepted - status code: 202

    The second step (which is executed in parallel for both build machines) downloads and prepares the Build Tool. The related commands are read from the circle.yml file.

    The third step (wait_for_droplets_and_update_test_inputs.sh) waits for the droplets to become operational, adds the necessary post startup configuration (e.g. activating TCP socket for Docker Swarm) and updates the inputs with the actual information (droplet IP addresses, private key file location). The script is periodically checking the droplet status by sending GET requests to DigitalOcean:

    Droplet(6748964) information retrieved successfully
    Droplet(6748964) status: new
    Droplet(6748964) information retrieved successfully
    Droplet(6748964) status: new
    Droplet(6748964) information retrieved successfully
    Droplet(6748964) status: new
    Droplet(6748964) information retrieved successfully
    Droplet(6748964) status: active
    Droplet(6748964) IPv4 address: 188.166.45.76

    Here we combine regular bash scripting (grep, awk) with Python (for complex data processing):

              IP_ADDRESS=$(\
              echo "$RESPONSE_BODY_JSON" | python -c \
    '
    if True:
              import json,sys;
              obj = json.load(sys.stdin);
              ipv4_container_list = obj["droplet"]["networks"]["v4"];
              public_ipv4_container_list = filter(lambda x : x["type"] == "public", ipv4_container_list);
              print public_ipv4_container_list[0]["ip_address"] if len(public_ipv4_container_list) > 0 else "";
    '\
              )

    Two CoreOS machines will be used as Swarm agents (the remaining one will have the Swarm manager) so we need to enable a Docker socket for these machines. The unit file which defines the socket was created at droplet startup time based on the cloud-config file. At this stage we need to enable the socket with the following command:

      LAST_LINE=$(ssh -i ${SSH_KEY_PATH} \
      -o UserKnownHostsFile=/dev/null \
      -o StrictHostKeyChecking=no \
      core@${DROPLET_IP} \
      'sudo systemctl enable docker-tcp.socket \
      && sudo systemctl stop docker \
      && sudo systemctl start docker-tcp.socket \
      && sudo systemctl start docker \
      && echo -e "\nSUCCESS"' | tail -n 1)

    Now the droplets are ready to be accessed. While the CoreOS cluster is properly configured, the Swarm cluster will be set up using flows since Swarm is based on Docker containers (need to run manager and agent containers on the machines). The last step before starting the Build Tool is updating the test input files with the actual data (e.g. IP addresses of the droplets):

    find test -type f -exec sed -i "s/<coreos_host_1>/${DROPLET_IP_ARRAY[0]}/g" {} +

    At this point everything is prepared to run the tests. The Build Tool is executed by activating the relevant test suites. The flows in these suites interact with the droplets using SSH calls. The Build Tool displays relevant statistics about the execution – coverage, how many test cases passed and cause of the problem in case of test failures.

    02:41:58 [INFO] 97% of the content has tests
    02:41:58 [INFO] Out of 158 executables, 154 executables have tests
    02:41:58 [INFO] 
    02:41:58 [INFO] ------------------------------------------------------------
    02:41:58 [INFO] BUILD SUCCESS
    02:41:58 [INFO] ------------------------------------------------------------
    02:41:58 [INFO] Found 153 slang files under directory: "/home/ubuntu/cloud-slang-content" and all are valid.
    02:41:58 [INFO] 11 test cases passed
    02:41:58 [INFO] 145 test cases skipped

    Once the tests finish – in the last step – we need to delete the droplets used for this build by sending DELETE requests to DigitalOcean (cleanup_env.sh).

    Managing Sensitive Data

    Since the working mechanism of our build system is based on heterogeneous components we need a secure way to store sensitive data (e.g. DigitalOcean API token for authentication). CircleCI provides the possibility to define global environmental variables where we can store this kind of data. These environmental variables are not included in builds which come from external pull requests (pull requests created by users who are not part of CloudSlang organization), otherwise they could be easily obtained. Someone could print them by modifying the circle.yml file inside the pull request.

    Conclusions

    In this post we’ve show you how CloudSlang developed its own continuous integration mechanism by combining technologies like the Build Tool (the worker that executes tests), GitHub to host the codebase, CircleCI (CI solution to define the skeleton of the build system) and DigitalOcean (IaaS provider to host testing machines).

    If you would like to learn more about the build system or just check out the project, visit us at CloudSlang’s website or GitHub page.

    And remember – keep the bar green …

     

  • The Sea Change that is DevOps – How it all started: Part 1

    The Sea Change that is DevOps – How it all started: Part 1

    Over the last 20 years, software has slowly taken over the world. Businesses that historically operated on 8-hour business days are now 24×7, navigating a global economy that never sleeps. The Internet enablement of everything has thrust what was originally an important support role into the lifeline of a business.

    A decade ago, Agile software development methodology forced more pressure into the IT system by deploying software at an ever-increasing rate to the point it’s at today – where innovative companies can deploy new software multiple times a day. DevOps is at the forefront of addressing the question of how IT deals with these problems, but like Agile before it, there’s a learning curve.

    In this two-part series, I will discuss how the IT world worked before DevOps and how development and operations teams united to adopt more Agile practices.

    How things were

    Before this sea change, a company would hire IT professionals who would purchase and configure servers, place them in a data center, copy mission critical software onto them and with some help from software engineering, get things running. After some quality checks, the IT team would lock down the datacenter controlling both physical and virtual access and “let things run.” The common way to provide stability was simply to not let anyone touch anything, as most problems have been (and still are) self-inflicted wounds. Keeping the system “static” kept a lot of problems from surfacing. The software was probably not more stable; you just didn’t find the problems as fast.

    In this world, IT professionals had a feast and famine existence. If a new service deployment was happening (usually every 3 to 6 months) it was an all hands on deck activity reminiscent of a rocket launch. The same manual deployment would happen, along with software engineering, database engineering, etc. Data migration would occur, new software would be installed, and the system would manually be brought back up. In the event of a software problem, or data migration problem, the team could elect to rollback and bring the old software back up. If things went well, then again some basic end-to-end quality assurance would take place and the new software release would be unleashed on the world. More progressive companies would do this for part of the system, diverting traffic to avoid perceived downtime. It would often take an entire night to do a new service release, and companies generally did them at night because downtime was not unusual.

    Then software development changed

    The competitive landscape that the Internet created along with the now ubiquitous SaaS business model made companies recognize that their ability to innovate the product was a competitive advantage. A lot of companies had adopted Agile software development practices in response to the increasingly high failure rate of larger efforts. Part of Agile is creating smaller development efforts that get code functional faster, reducing the size of the endeavor. This is commonly referred to as a “software sprint.” This promise of innovating the product faster was very alluring, especially to Web 1.0 companies that were now in feature battles with more nimble Web 2.0 companies who had more quickly adopted Agile. It was becoming more and more evident that the problem was shifting from an issue of creating software fast enough to deploying the necessary code in an expedient manner.
    The big problem was the deployment stage of the process. IT teams were accustomed to changing production systems every three to six months. This combined with a trusted model that largely kept software developers out of production systems, effectively nullified any Agile gains in SaaS businesses. In other words, half the product development cycle had been fixed with Agile, but the other half deploying the software had not yet caught up.

    Operations as a changing landscape

    Major changes were also occurring for operations inside companies, many of which were driven by the development side of the house.

    • Virtual server technology started to get major traction within production environments. This allowed teams to treat servers as software. You no longer had to run the operating system and application on a physical server, you could run them on a virtual server (that ran on physical servers). The configuration of servers that, by hand, took an incredible amount of time, could essentially be defined once and then cloned, the same way you would clone a file. Deploying a new server was much easier, and a corrupt server could simply be deleted and reborn in minutes. All these virtual servers could be managed by a single piece of software called a hypervisor, with which creating a new “server” would take a minute, when it used to take weeks.
    • Puppet and Chef were born. At the same time development organizations, recognizing this major problem with deployment, started addressing the production configuration problem with tools such as Puppet and Chef that essentially allow software and IT teams to codify the configurations of virtual and physical servers and deployments of new code. This allowed for repeatable processes that could be rapidly done and redone. No longer did your IT team have to install software by hand, instead they could code it.
    • Continuous integration and delivery enabled software teams to use newly developed tools like Jenkins to do nightly software builds, perform unit tests of parts of the software and automatically deploy software into production. All of these tasks had been highly manual operations historically and fraught with mistakes and inconsistencies. Codifying these steps would give way to deploying software within minutes or seconds rather than days or hours.

    Most importantly, all of these efforts were largely driven by the development of more progressive operations in the company. The operations side of most companies was never conceived as a “maker” culture; the handwriting was on the wall – operations had to change or it will would have become a victim of this revolution. I’ll take a look at some of the resulting changes in the second part of this series.

  • American Psychological Association Finds CI & CD Therapeutic

    American Psychological Association Finds CI & CD Therapeutic

    The American Psychological Association (APA), the largest scientific and professional organization for psychology in the U.S. publishes the PsycINFO database with 4-million records and more than 90 peer reviewed journals, books, and other publications, starts Beverly Jamison, Sr. Director, IT Architecture, The APA. “We maintain a database of psychological tests and measures and psychotherapy demonstration videos,” says Jamison. The APA publishes member information and other data as well.

    Because a broad audience including researchers, practitioners, members of other professions, students, the media, and the public use this data, the APA keeps a precise inventory of the data and its elements, checking it for quality and delivering it in a number of ways including as integrated and multimedia materials in B2B and B2C contexts.

    APA Dev and Ops Before & After CI and CD

    When Jamison joined the APA, some odd number of perl / shell-based coders like her used the VI editor as their IDE while others of the ColdFusion persuasion used Dreamweaver as their IDE. Developers deployed direct to the live system, at off hours, with the developers and perhaps one QA person testing AFTER the deployment was completed, says Jamison.

    Today, the APA uses svn for version control for legacy development projects where they are accustomed to that and Git and BitBucket for newer projects that seem to benefit from that. “We use Ant for the scripts to deploy code from version control. For unit testing, we use X-Ray for xquery, JUnit for java, and mocha for javascript,” says Jamison.

    The APA uses the Roxy community tool for deployments to MarkLogic to address MarkLogic database instances and configurations, which provides uniformity of the MarkLogic databases, explains Jamison.

    The nature and purpose of each team inside Dev and Ops determines the usage of the tools. The work of the MarkLogic team dictates one application usage while the priorities of the identity and integration services team require another. The MarkLogic team deals with data services and data models that are often complex; as such they make a great deal of use of unit testing to ensure that a single change doesn’t lead to broken software throughout, explains Jamison. Identity and integration services uses Jenkins to script their builds and to ensure that each build is current; QA analysts test to ensure that their complex scenarios are reliable, says Jamison. Likewise, the UI team has still another set of priorities and usages.

    A Panoramic View of the APA’s New Feature Development Process

    First the developer will check out a branch from subversion to a local IDE, make and then test the altered code and run unit and regression tests on existing code, and update unit tests, configuration scripts, and any script changes needed, explains Jamison. The process would then include updating and tagging any JIRA tickets with the appropriate version number for the forthcoming release.

    The code would deploy from svn to the given IDE for QA testing, which developers or engineers would run depending on the size and complexity of the system and the current system state with respect to release to the outside world, says Jamison.

    “Then the code would deploy to the integrated UAT environment for testing by the business team. Once approved there, we would schedule a production release with the systems engineers handling deployment to live public facing servers,” says Jamison.

    How CI & CD Impacts / Empowers This Development Process

    CI & CD processes hand the developers and engineers greater freedom in adding new features, relieving their fears of doing extensive damage to existing software releases. A minor feature change or bug fix could see the steps in the above process happen in close succession as CI and CD processes avoid the risks of having to revert the code. “A major new feature or change to a data model would mean taking these steps on separate days with distinct and formal signoffs on each,” says Jamison.

    Final Thoughts

    In a word to the wise, Jamison reminds that while tools matter, it is how the teams commit to using them in disciplined CI and CD practices that counts.

  • Mobile developer trends for CI and the cloud

    Mobile developer trends for CI and the cloud

    Mobile developers understand the rising importance of continuous integration (CI). The promise of CI is to speed up the overall velocity of the app team by building and testing every single code change. This environment of rapid change means that code integration issues are caught early, and testers and beta users can provide feedback on these changes as quickly as possible. As CI has become commonplace for app development teams, and many are moving their CI infrastructure to the cloud, the importance of build and regression test automation has grown.

    To that end, we thought it would be important to generate a research report by examining survey data from more than 500 mobile app developers and benchmarked usage data from more than 250,000 automated builds, tests and releases on the Ship.io platform. This Mobile Metrics Benchmark Report shares insights and trends around the Continuous Integration (CI) landscape in regards to mobile app development. Key areas of focus for the report include CI adoption across major mobile operating systems (iOS, Android), frequency of testing, releasing and checking code, app build times and frequency, and common build failure reasons across geographies around the world.

    v3-Ship_io-Infographic-FINAL-8_3_15-01-580x1024

     

    OVERALL CI ADOPTION
    Of app teams surveyed, the majority are leveraging CI. Those not leveraging CI are often building only on-demand when they want to test a build, or are building with a simple regularly scheduled nightly or weekly build scheduler. Of teams that are leveraging CI processes, the majority of them are running some form of test automation on each build. Here’s a breakout:

    • Less than 5 per week: 15%
    • Between 5 and 25 per week: 33%
    • Between 25-50 per week: 33%
    •  More than 50 per week: 19%
    • No, not doing CI right now: 37%
    • Yes, doing CI builds and tests: 35%
    • Yes, doing CI builds: 28%

    THE CLOUD CI ADOPTION LANDSCAPE: Cloud CI Adoption: iOS vs Android
    Many app teams have adopted Continuous Integration as part of their engineering processes. Some teams have set up CI as an on-premise service, but many are moving this to the cloud for reasons such as cost savings, focus, and reliability of the CI system. An oft-cited reason for moving to cloud CI systems managed by others is the complexity and cost of keeping up with all the changes in the iOS and Android build and test ecosystem.

    Of all developers surveyed with an interest in Cloud CI, but not necessarily using CI systems today, the majority (50%) are only focused on iOS—ignoring Android altogether. Other developers are focused on both platforms, with a small minority focusing only on Android.

    PUBLIC vs. PRIVATE APPS
    Developers with an interest in CI are overwhelmingly building apps for Google Play and the App Store. Only a small fraction of these developers are building apps for internal use, or with a limited number of customers. Many of these internal-facing app teams have smaller app teams and longer release cycles, presumably diminishing their need and interest in continuous integration systems.

    WHY BUILDS BREAK AND BUILD SPEED METRICS
    As many app teams have moved to a continuous integration (CI) model for development, they produce many more builds. This increase in build frequency means that the time spent building is far more significant, and broken builds can randomize and delay product progress. The data shows that the majority of build breaks are avoidable, and the time spent building apps is low, but iOS builds are about twice as fast on average versus Android.

    Analyzing the source of build breaks across both iOS and Android reveals that there is a very long tail of build breaks as many engineers would suspect. Builds often break due to of various developer code syntax issues, but several build breaks account for the vast majority (74%) of all breaks in cloud CI builds:

    • Missing File or Directory: Developers often forget to check dependencies and new files into the code repository.
    • Lint Errors: When ‘lint’ is enabled on a build, it often catches common programming errors.
    • Unit Tests: Many apps have regression test automation at the unit level. These tests fail during the build process, catching either changes in the app, or regressions.
    • Linking: Builds often fail at link time because a referenced 3rd party library wasn’t added to the dependencies list, or project dependencies were not updated.
    • Code Signing: The process of signing apps is still error prone. From missing signature files, or differences in debug versus release build configurations, code signing causes many CI headaches.

    The good news is that most all of these build breaks could be caught by developers having a separate ‘clean’ enlistment and building and running lint locally. Even more breaks would likely be prevented if developers simply executed unit tests before submitting new code. Barring that, cloud CI systems make it easy to catch all these issues, and mark the build as failed until developers resolve the break.

    BUILD TIMES: iOS vs. ANDROID
    When app builds break the team is often blocked and waiting for a new build. Build times are now a critical path for app teams. Analysis of iOS versus Android build times reveals that although iOS app build times are about twice as fast on average, the build times are still reasonably short at 2 minutes and 4 minutes on average, respectively. A deeper look into the build time data shows that very few app build times, regardless of platform, exceed 30 minutes. The majority of app build times are less than one minute. An interesting aspect of build times is the fact that more Android than iOS app builds complete in less than 2 minutes. But of all large/complex app builds (longer than 2 minutes), iOS app build times are generally faster by a factor of 2.

    COMMIT FREQUENCY OF IOS vs. ANDROID CLOUD CI TEAMS
    Of the top 40 apps with the most frequent commits in the study data, 67% of them were iOS Apps. It is worth noting that the study data had builds from app teams that built both Android and iOS versions of their apps. iOS developers seem to be committing code more frequently and adopting the CI model of small, continuous commits.

    COMMIT FREQUENCIES: IOS vs. ANDROID
    iOS developers make far more revisions than Android developers. Across the spectrum of commit frequency, iOS developers, on average, are making twice as many commits as Android developers. The majority of apps have one commit per week, or fewer. Of those that are very active, defined as committing code more than 3 times per week, about two thirds of those developers are working on iOS. The aberration seen where Android developers are building 6 times a week, is due to a single app vendor with many apps, all sharing a common code base with many Android apps (with commit frequencies at 6 times per week). In general, iOS developers are about twice as likely to make more than 3 commits per week versus their Android counterparts. In total, iOS developers, on average, are making twice as many commits as Android developers.

    TOP PRIORITIES INCLUDE FASTER RELEASES
    Of all the things app teams were looking to prioritize in the coming year, faster release and update frequencies (41%) was a close second only to improving overall app performance at 48%. Teams are quickly migrating to Cloud CI systems as a way to accelerate their overall velocity. Cloud CI enables teams to focus their time and money on other priorities such as performance and security.

    WHY NOT CI?
    The reasons why teams haven’t adopted CI vary widely. 49% are interested and plan to move to CI eventually but haven’t because of prioritization. Some teams believe they are too small to benefit from the value of CI as their team only has one or two people working on the builds, or they have so few code revisions that they prefer to deal with builds manually. A minority of app teams are concerned with the cost in money or time to move to a CI system.

    Why Deverlopers are Not Adopting CI

    CONCLUSION
    These Ship.io study results show that the world of CI for app teams is changing quickly and varies between iOS and Android app teams. Knowing the macro-level trends and learning from them, can greatly impact your app teams efficiency. As app teams accelerate due to CI adoption and agile practices, teams are often spending an inordinate amount of time focusing on their local and custom build and test infrastructure. Those app teams that have moved to the cloud are saving money and time and focusing more on their app design and implementation.

    • CI Adoption: Cloud CI adoption is on the rise, especially in the iOS community. iOS developers are more aggressively adopting cloud CI than Android developers. The number of teams adopting Cloud CI is doubling every 6 months.
    • Commit Frequency: There is a wide range of commit frequencies across iOS and Android. iOS app developers generally have twice as many commits as Android developers. The commit frequency and the number of builds range from a high of around 16 per day, to a low of once every other week.
    • Source Control Popularity: Two cloud source control repositories represent almost all cloud CI systems: GitHub and Bitbucket. The momentum is strong with Bitbucket which saw its share of usage double in just the past 4 months. Android users seem are more aggressively moving to Bitbucket, but iOS developers aren’t far behind.
    • Build Breaks: Several common issues account for the majority of build breaks, but there is a very long tail of build break reasons. The good news is that many of these are avoidable.
    • Build Time: Build times on iOS and Android are similar and range from mere seconds to a high of 40+ minutes for apps with larger code bases and dependencies.

    Download the full report here

    shipIO-report

     

     

     

     

    About the Author/Prathap Dendi

    leadership-prathap-dendiPrathap is GM for Ship.io, and VP Business Development for Electric Cloud. He drives strategic partnerships that help us deliver broader solutions to our customers. Electric Cloud has forged strategic partnerships with companies providing industry-leading tools and services in order to deliver software production automation to our customers.